home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_02_06 / 2n06059a < prev    next >
Text File  |  1991-04-30  |  14KB  |  605 lines
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <io.h>
  4. #include <stdlib.h>
  5. #include <graph.h>
  6. #include <string.h>
  7. #include <ctype.h>
  8. #include "StdWin.h"
  9.  
  10.  
  11. /* malloc statics */
  12. static WORD LocalEntries;
  13. static WORD LocalTotalSize=0;
  14. static WORD GlobalEntries;
  15. static WORD GlobalTotalSize=0;
  16. static VOID **LocalMemPtrs;
  17. static HANDLE *LocalMemHandles;
  18. static HANDLE *GlobalMemHandles;
  19. static VOID huge **GlobalMemPtrs;
  20.  
  21. BYTE TextBuffer[1024];
  22. #define TABSIZE 4
  23.  
  24. /* two states used by printf */
  25. static int AnsiTextState=TEXT,NewLineState=0;
  26.  
  27.  
  28. /* atexit function pointer */
  29. (_cdecl _FAR_ _LOADDS_ *ExitCallFunc)(void);
  30. int ExitCallInit = 0;
  31.  
  32. /********************************************************/
  33. /* malloc() & halloc() keep a list of all the allocated
  34.    pointers and handles so that they can later be freed */
  35. /********************************************************/
  36. void *malloc(size)
  37. size_t size;
  38. {
  39.  static HANDLE MemHandle,MemPtr;
  40.  static void *Ptr;
  41.  if(!LocalTotalSize)         /* not initialized */
  42.     {
  43.     MemHandle = LocalAlloc(LMEM_MOVEABLE,50);
  44.     if(!MemHandle) return(0);
  45.     MemPtr = LocalAlloc(LMEM_MOVEABLE,50);
  46.     if(!MemPtr) return(0);
  47.     LocalTotalSize = 25;
  48.     }
  49.  if(LocalEntries >= LocalTotalSize && LocalEntries != 0)
  50.     {
  51.     MemHandle = LocalReAlloc(MemHandle,100,LMEM_MOVEABLE);
  52.     if(!MemHandle) return(0);
  53.     MemPtr = LocalReAlloc(MemPtr,100,LMEM_MOVEABLE);
  54.     if(!MemPtr) return(0);
  55.     LocalTotalSize = 50;
  56.     }
  57.  LocalMemHandles = (HANDLE *)LocalLock(MemHandle);
  58.  *LocalMemPtrs = LocalLock(MemPtr);
  59.  if(!LocalMemHandles || !*LocalMemPtrs) return(0);
  60.  
  61.  if(!(LocalMemHandles[LocalEntries] =
  62.             LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,size)))
  63.         {
  64.         LocalCompact(0xffff);
  65.         if(!(LocalMemHandles[LocalEntries] =
  66.             LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,size)))
  67.             return(0);
  68.         }
  69.  if(!(Ptr = LocalLock(LocalMemHandles[LocalEntries])))
  70.         return(0);
  71.  LocalMemPtrs[LocalEntries] = Ptr;
  72.  LocalEntries++;
  73.  LocalUnlock(MemHandle);
  74.  LocalUnlock(MemPtr);
  75.  
  76.  return(Ptr);
  77. }
  78.  
  79. /***************************************
  80. function : halloc
  81. ***************************************/
  82.  
  83. void far *halloc(n,size)
  84. long n;
  85. size_t size;
  86. {
  87.  static VOID huge *Ptr;
  88.  static HANDLE MemHandle,MemPtr;
  89.  if(!GlobalTotalSize)         /* not initialized */
  90.     {
  91.     MemHandle = LocalAlloc(LMEM_MOVEABLE,50);
  92.     if(!MemHandle) return(0);
  93.     MemPtr = LocalAlloc(LMEM_MOVEABLE,50);
  94.     if(!MemPtr) return(0);
  95.     GlobalTotalSize = 25;
  96.     }
  97.  if(GlobalEntries >= GlobalTotalSize && GlobalEntries != 0)
  98.     {
  99.     MemHandle = LocalReAlloc(MemHandle,GlobalTotalSize+50,
  100.         LMEM_MOVEABLE);
  101.     if(!MemHandle) return(0);
  102.     MemPtr = LocalReAlloc(MemPtr,GlobalTotalSize + 50,
  103.         LMEM_MOVEABLE);
  104.     if(!MemPtr) return(0);
  105.     GlobalTotalSize += 25;
  106.     }
  107.  GlobalMemHandles = (HANDLE *)LocalLock(MemHandle);
  108.  *GlobalMemPtrs = LocalLock(MemPtr);
  109.  
  110.  if(!GlobalMemHandles || !*GlobalMemPtrs) return(0);
  111.  if(!(GlobalMemHandles[GlobalEntries] =
  112.             GlobalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,
  113.             (long)size*n)))
  114.         {
  115.         GlobalCompact(-1L);
  116.         if(!(GlobalMemHandles[GlobalEntries] =
  117.             GlobalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,
  118.             (long)size*n)))
  119.             return(0);
  120.         }
  121.  if(!(Ptr =
  122.     (VOID FAR *)GlobalLock(GlobalMemHandles[GlobalEntries])))
  123.         return(0);
  124.  GlobalMemPtrs[GlobalEntries] = Ptr;
  125.  
  126.  GlobalEntries++;
  127.  LocalUnlock(MemHandle);
  128.  LocalUnlock(MemPtr);
  129.  
  130.  return(Ptr);
  131. }
  132.  
  133. /***************************************
  134. function : free
  135. ***************************************/
  136.  
  137. void free(ptr)
  138. void *ptr;
  139. {
  140.  int i = 0;
  141.  while(i < LocalEntries)
  142.     {
  143.     if(LocalMemPtrs[i] == ptr)
  144.         {
  145.         LocalUnlock(LocalMemHandles[i]);
  146.         LocalFree(LocalMemHandles[i]);
  147.         return;
  148.         }
  149.     i++;
  150.     }
  151.  
  152. }
  153.  
  154. /***************************************
  155. function : hfree
  156. ***************************************/
  157.  
  158. void hfree(hugeptr)
  159. void huge *hugeptr;
  160. {
  161.  int i = 0;
  162.  while(i < GlobalEntries)
  163.     {
  164.     if(GlobalMemPtrs[i] == hugeptr)
  165.         {
  166.         GlobalUnlock(GlobalMemHandles[i]);
  167.         GlobalFree(GlobalMemHandles[i]);
  168.         return;
  169.         }
  170.     i++;
  171.     }
  172.  
  173. }
  174.  
  175.  
  176. /***************************************
  177. function : printf
  178. ***************************************/
  179.  
  180. int printf(str,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,
  181.     arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,
  182.     arg18,arg19,arg20,arg21,arg22)
  183. const char _FAR_ *str;
  184. WORD arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,
  185.     arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,
  186.     arg20,arg21,arg22;
  187. {
  188.  HDC hDC;
  189.  HANDLE hOldFont,hFont;
  190.  DWORD dwExtent;
  191.  int n,i,CharCount;
  192.  static BYTE number[8];
  193.  MSG msg;
  194.  /* 1 of 2 external message loops not found in
  195.                     WinMain(), another in getch*/
  196. Loop:
  197.  /* clear the message queue */
  198.  while(PeekMessage(&msg,NULL,0,0xFFFF,PM_REMOVE)){
  199.         TranslateMessage(&msg);
  200.         DispatchMessage(&msg);}
  201.  /* if the break key is pressed, hold for another key */
  202.  if(BreakSet) goto Loop;
  203.  
  204.  CharCount = sprintf(TextBuffer,str,arg1,arg2,arg3,arg4,
  205.     arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,
  206.     arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22);
  207.  /* see if output is redirected or piped */
  208.  if(hOutFile)
  209.     write(hOutFile,TextBuffer,CharCount);
  210.  if(Redirected) return(CharCount);
  211.  
  212.  hDC=GetDC(hStdWinWnd);
  213.  SetMyDC(hDC);
  214.  ptr = TextBuffer;
  215. while(*ptr)
  216.  {
  217.  /* set up the AnsiTextState to start with */
  218.  if((*ptr == 0x1b) && (*(ptr + 1) == '['))
  219.     AnsiTextState = ANSI;
  220.  else AnsiTextState = TEXT;
  221.  
  222.  switch(AnsiTextState){
  223.     case TEXT:
  224.         hFont = hFont1;         /* default font */
  225.     if(*ptr)
  226.         { int i;
  227.         BYTE buffer[120];
  228.         hOldFont = SelectObject(hDC, hFont);
  229.         CharCount = 0;
  230.         ptr2 = ptr;
  231.         while(*ptr2 == '\b')    /* process a backspace */
  232.             {memmove(ptr2,ptr2+1,strlen(ptr2));
  233.              if(DisplayCol){
  234.                 xCurrentPos -= ScreenBuffer[DisplayLine]
  235.                     [DisplayCol].xExtent;
  236.                 DisplayCol--;
  237.                 HideCaret(hStdWinWnd);
  238.                 TextOut(hDC,xCurrentPos,yCurrentPos," ",1);
  239.                 ShowCaret(hStdWinWnd);
  240.                 }
  241.             }
  242.         /* advance until a control character */
  243.         while(*ptr2)
  244.             {
  245.             if((*ptr2 == 0x1b) && (*(ptr2 + 1) == '['))
  246.                 break;
  247.             if((*ptr2 == 0x0d) || (*ptr2 == 0x0a))
  248.                 break;
  249.             else NewLineState = 0;
  250.             if(*ptr2 == '\b')
  251.                break;
  252.             if((DisplayCol + CharCount) >= MAXCOLUMNS)
  253.                 break;
  254.             CharCount++;
  255.             if(*ptr == '\t')    /* expand tab to spaces */
  256.                 {
  257.                 i = strlen(TextBuffer);
  258.                 memmove(ptr2 + TABSIZE-1,ptr2,
  259.                     i - (ptr2-TextBuffer)+1);
  260.                 i = TABSIZE;
  261.                 while(i--) *ptr2++ = ' ';
  262.                 CharCount += TABSIZE-1;
  263.                 }
  264.             ptr2++;
  265.             }
  266.  
  267.         if(DisplayLine >= MAXROWS)
  268.             yCurrentPos = Scrollup(hStdWinWnd,yCurrentPos);
  269.  
  270.         HideCaret(hStdWinWnd);
  271.         TextOut(hDC,xCurrentPos,yCurrentPos,ptr,CharCount);
  272.         xCurrentPos +=
  273.             LOWORD(GetTextExtent(hDC,ptr,CharCount));
  274.         SetCaretPos(xCurrentPos,yCurrentPos);
  275.         ShowCaret(hStdWinWnd);
  276.         /* copy the new characters to the screen buffer */
  277.         for(i = DisplayCol;i < DisplayCol + CharCount;i++)
  278.             { ScreenBuffer[DisplayLine][i].Char = *ptr;
  279.               ScreenBuffer[DisplayLine][i].xExtent =
  280.                     LOWORD(GetTextExtent(hDC,ptr++,1));
  281.               ScreenBuffer[DisplayLine][i].Color =
  282.                 rgbTextColor;
  283.               ScreenBuffer[DisplayLine][i].hFont = hFont;
  284.               if(i < MAXCOLUMNS){
  285.               ScreenBuffer[DisplayLine][i+1].Char = 0;
  286.               ScreenBuffer[DisplayLine][i+1].Color = 0L;
  287.               ScreenBuffer[DisplayLine][i+1].hFont = 0;
  288.               }
  289.             }
  290.         DisplayCol += CharCount;
  291.  
  292.         if((DisplayCol >= MAXCOLUMNS) && !iscntrl(*ptr2)){
  293.             /* force a newline for a wrap */
  294.             NewLineState = 1;
  295.             DisplayCol = 0;
  296.             if(hOutFile) write(hOutFile,"\r",1);
  297.             xCurrentPos = 0;
  298.             }
  299.         if(*ptr2 == 0x0d){
  300.             DisplayCol = 0;
  301.             if(hOutFile) write(hOutFile,"\r",1);
  302.             xCurrentPos = 0;
  303.             if(!NewLineState) ptr2++;
  304.             NewLineState = 1;}
  305.  
  306.         if((*ptr2 == 0x0a) || NewLineState)
  307.             {
  308.             DisplayLine++;
  309.             if(!NewLineState)
  310.                 {
  311.                 DisplayCol = 0;
  312.                 if(hOutFile) write(hOutFile,"\r",1);
  313.                 xCurrentPos = 0;
  314.                 }
  315.             if(*ptr2 == 0x0a) ptr2++;
  316.             NewLineState = 0;
  317.             dwExtent = GetTextExtent(hDC,"A",1);
  318.             yCurrentPos += LineExtents[DisplayLine] =
  319.                 HIWORD(dwExtent);
  320.  
  321.             HideCaret(hStdWinWnd);
  322.             SetCaretPos(xCurrentPos,yCurrentPos);
  323.             ShowCaret